An Efficient Monte Carlo-based Probabilistic Time-Dependent Routing Calculation Targeting a Server-Side Car Navigation System

Incorporating speed probability distribution to the computation of the route planning in car navigation systems guarantees more accurate and precise responses. In this paper, we propose a novel approach for dynamically selecting the number of samples used for the Monte Carlo simulation to solve the Probabilistic Time-Dependent Routing (PTDR) problem, thus improving the computation efficiency. The proposed method is used to determine in a proactive manner the number of simulations to be done to extract the travel-time estimation for each specific request while respecting an error threshold as output quality level. The methodology requires a reduced effort on the application development side. We adopted an aspect-oriented programming language (LARA) together with a flexible dynamic autotuning library (mARGOt) respectively to instrument the code and to take tuning decisions on the number of samples improving the execution efficiency. Experimental results demonstrate that the proposed adaptive approach saves a large fraction of simulations (between 36% and 81%) with respect to a static approach while considering different traffic situations, paths and error requirements. Given the negligible runtime overhead of the proposed approach, it results in an execution-time speedup between 1.5x and 5.1x. This speedup is reflected at infrastructure-level in terms of a reduction of around 36% of the computing resources needed to support the whole navigation pipeline

Pegasus: Performance Engineering for Software Applications Targeting HPC Systems

Developing and optimizing software applications for high performance and energy efficiency is a very challenging task, even when considering a single target machine. For instance, optimizing for multicore-based computing systems requires in-depth knowledge about programming languages, application programming interfaces, compilers, performance tuning tools, and computer architecture and organization. Many of the tasks of performance engineering methodologies require manual efforts and the use of different tools not always part of an integrated toolchain. This paper presents Pegasus, a performance engineering approach supported by a framework that consists of a source-to-source compiler, controlled and guided by strategies programmed in a Domain-Specific Language, and an autotuner. Pegasus is a holistic and versatile approach spanning various decision layers composing the software stack, and exploiting the system capabilities and workloads effectively through the use of runtime autotuning. The Pegasus approach helps developers by automating tasks regarding the efficient implementation of software applications in multicore computing systems. These tasks focus on application analysis, profiling, code transformations, and the integration of runtime autotuning. Pegasus allows developers to program their strategies or to automatically apply existing strategies to software applications in order to ensure the compliance of non-functional requirements, such as performance and energy efficiency. We show how to apply Pegasus and demonstrate its applicability and effectiveness in a complex case study, which includes tasks from a smart navigation system

Hyperparameter search in periodic vehicle routing problem

The large number of real-world applications have shown that the use of computational method for distribution process planning produces substantial savings. Many of these applications lead to problem generally known as Vehicle Routing Problem. The real-world applications are highly computationally demanding for larger instances. This article aims to show the possibilities and benefits of using hyperparameter search for solving the Periodic Vehicle Routing Problem for exhausted oil collection by execution on the supercomputing infrastructure using HyperLoom platform. HyperLoom is an open source platform for defining and executing scientific pipelines in a distributed environment. This experiment was run on the supercomputer Salomon operated by IT4Innovations

DSL and Autotuning Tools for Code Optimisation on HPC Inspired by Navigation Use Case

When targeting high performance computing (HPC) platforms, improving the performance and scalability of code is often a tedious and time consuming task. The code has to be executed and even compiled many times under different conditions in order to observe its behaviour on the target hardware. These experiments are performed with the goal of estimating an optimal set of the run-time environment parameters to achieve optimal performance and energy efficiency. This optimization task is best performed automatically, but due to the heterogeneous nature of the source codes and the HPC platform, fully automation is often hard to implement. The domain specific language (DSL) and toolflow approach proposed in the ANTAREX project ( www.antarex-project.eu ) can provide the mechanisms needed for addressing properly the problems previously described. The DSL being developed is based on the LARA DSL [1] and allows to specify strategies for code instrumentation and code transformations, including the required code adaptation for dynamic autotuning [2]. By using instrumentation strategies, the measurements can be integrated seamlessly into the development process, e.g., as a standalone stage in the continuous integration process. The ANTAREX project plans to demonstrate the usage of the LARA DSL and the autotuning approach on two use cases in cooperation with commercial partners, HPC Accelerated Drug Discovery System (Dompe), and the Self-adaptive Navigation System (Sygic). The poster is focused on the presentation of the DSL and autotuning tools for the self-adaptive navigation system use case, which basic idea is to combine server-side and client-side data knowledge and their routing capabilities to provide the most efficient navigation system in the context of smart cities. In such a use case, we assume a significantly large portion of drivers participating in the system. The efficiency is essential given that the routing system needs to serve many requests requiring potentially huge computation power. Then still, even without limits to be reached, it is desirable to optimize the execution of such a system with respect to the energy efficiency. The probabilistic Time-Dependent Travel Time Computation algorithm [3] has been selected for the demonstration of DSL and autotuning tools usage in the Self-adaptive Navigation System. The input for the algorithm is a departure time and a selected route composed as a line of road segments. A Monte Carlo simulation (MCS) is used for the computation of the probability distribution of travel time for the selected route. The simulation randomly selects probabilistic speed profiles on road segments and computes travel time at the end of the route. Many MCS iterations are needed to obtain enough travel times for the construction of the probability distribution of travel time. The number of simulation iterations greatly affects the precision of the result

ANTAREX - AutoTuning and adaptivity approach for energy efficient eXascale HPC systems

The main goal of the ANTAREX project is to express by a Domain Specific Language (DSL) the application self-adaptivity and to runtime manage and autotune applications for green and heterogeneous High Performance Computing (HPC) systems up to the Exascale level. Key innovations of the project include the introduction of a separation of concerns between self-adaptivity strategies and application functionalities. The DSL approach will allow the definition of energy-efficiency, performance, and adaptivity strategies as well as their enforcement at runtime through application autotuning and resource and power management

Autotuning and adaptivity approach for energy efficient Exascale HPC systems: The ANTAREX approach

The main goal of the ANTAREX1project is to express by a Domain Specific Language (DSL) the application self-adaptivity and to runtime manage and autotune applications for green and heterogeneous High Performance Computing (HPC) systems up to the Exascale level. Key innovations of the project include the introduction of a separation of concerns between self-adaptivity strategies and application functionalities. The DSL approach will allow the definition of energy-efficiency, performance, and adaptivity strategies as well as their enforcement at runtime through application autotuning and resource and power management

ANTAREX: A DSL-Based approach to adaptively optimizing and enforcing extra-functional properties in high performance computing

The ANTAREX project relies on a Domain Specific Language (DSL) based on Aspect Oriented Programming (AOP) concepts to allow applications to enforce extra functional properties such as energy-efficiency and performance and to optimize Quality of Service (QoS) in an adaptive way. The DSL approach allows the definition of energy-efficiency, performance, and adaptivity strategies as well as their enforcement at runtime through application autotuning and resource and power management. In this paper, we present an overview of the ANTAREX DSL and some of its capabilities through a number of examples, including how the DSL is applied in the context of one of the project use cases